Session 2 - Societal-consciousness in the computing curricula: A Time for serious introspection

This paper addresses the growing need for inculcating appropriate ethics within the computing curriculum by fostering the development of a societally-conscious ethical framework among our students to address the use of information technology vis-à-vis government, business and society. We propose a new integrated model based approach (IDEA) and suggest its adoption to encourage students on reflecting upon the social and ethical ramifications of technology, beyond the narrow, project focused tunnel vision that currently (subliminally) exists in many computing curricula, and in particular, in today’s profit-focused, consulting and contract-based software industry

Using Bug Reports as a Software Quality Measure

Bugzilla is an online software bug reporting system. It is widely used by both open-source software projects and commercial software companies and has become a major source to study software evolution, software project management, and software quality control. In some research studies, the number of bug reports has been used as an indicator of software quality. This paper examines this representation. We investigate whether the number of bug reports of a specific version of a software product is correlated with its quality. Our study is performed on six branches of three open-source software systems. Our results do not support using the number of bug reports as a quality indicator of a specific version of an evolving software product. Instead, the study reveals that the number of bug reports is in some ways correlated with the time duration between product releases. Finally, the paper suggests using accumulated bug reports as a means to represent the quality of a software branch

Analysis of Software Binaries for Reengineering-Driven Product Line Architecture\^aAn Industrial Case Study

This paper describes a method for the recovering of software architectures from a set of similar (but unrelated) software products in binary form. One intention is to drive refactoring into software product lines and combine architecture recovery with run time binary analysis and existing clustering methods. Using our runtime binary analysis, we create graphs that capture the dependencies between different software parts. These are clustered into smaller component graphs, that group software parts with high interactions into larger entities. The component graphs serve as a basis for further software product line work. In this paper, we concentrate on the analysis part of the method and the graph clustering. We apply the graph clustering method to a real application in the context of automation / robot configuration software tools.Comment: In Proceedings FMSPLE 2015, arXiv:1504.0301

Coupon characteristics and redemption intentions: A segment-level analysis

The authors investigate how different segments of consumers react to different coupon characteristics, such as face value and method of distribution. They utilize a latent segmentation approach to identify the underlying segments. The empirical analysis suggests that different segments of consumers place varying emphasis with regard to economic benefits, psychic benefits, effort costs, and substitution costs. A further examination of the derived segments with respect to consumer correlates such as psychological, attitudinal, behavioral, and demographic characteristics reveals that coupon-related consumer characteristics, rather than demographics, exhibit significant and meaningful differences across these segments. Implications of the segment-level analysis for evaluating coupon drops and managing promotional expenditures are also discussed. © 1998 John Wiley & Sons, Inc.Peer Reviewedhttp://deepblue.lib.umich.edu/bitstream/2027.42/34943/1/5_ftp.pd

Using Peer Comparison Approaches to Measure Software Stability

Software systems must change to adapt to new functional requirements and new nonfunctional requirements. This is called software revision. However, not all the modules within the system need to be changed during each revision. In this paper, we study how frequently each module is modified. Our study is performed through comparing the stability of peer software modules. The study is performed on six open-source Java projects: Ant, Flow4j, Jena, Lucence, Struct, and Xalan, in which classes are identified as basic software modules. Our study shows (1) about half of the total classes never changed; (2) frequent changes occur to small number of classes; and (3) the number of changed classes between current release and next release has no significant relations with the time duration between current release and next release. Keywords: software evolution; software revision; software stability; class stability; open-source project; Java clas

Examining the Relationships between Software Coupling and Software Performance: A Cross-platform Experiment

Coupling measures the degree of dependencies between software modules. Considerable research has been performed to relate software coupling with software understandability, maintainability, and reusability, which are the key properties of software maintenance and evolution. However, only a few research works have been reported that study the relationships between software coupling and software performance. This study implemented two benchmarks that measure and compare the performance of software programs implemented with different kinds of coupling, common coupling, data coupling, and stamp coupling. The experiment is run on three different platforms, Windows, Linux, and Mac.The results show that (1) the relative performance of systems implemented using different software coupling is platform dependent; (2) while loose coupling is more favorable than strong coupling with respect to software maintenance and evolution, it has the drawback of reduced performance of a software program. Based on this study, we make some suggestions to balance the use of strong coupling and loose coupling in designing evolving software systems in order to achieve both maintainability and evolvability without compromising on performance